.TH std::is_scalar 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::is_scalar \- std::is_scalar

.SH Synopsis
   Defined in header <type_traits>
   template< class T >              \fI(since C++11)\fP
   struct is_scalar;

   std::is_scalar is a UnaryTypeTrait.

   If T is a scalar type, provides the member constant value equal true. For any other
   type, value is false.

   If the program adds specializations for std::is_scalar or std::is_scalar_v, the
   behavior is undefined.

.SH Template parameters

   T - a type to check

   Helper variable template

   template< class T >                                       \fI(since C++17)\fP
   inline constexpr bool is_scalar_v = is_scalar<T>::value;



Inherited from std::integral_constant

.SH Member constants

   value    true if T is a scalar type, false otherwise
   \fB[static]\fP \fI(public static member constant)\fP

.SH Member functions

   operator bool converts the object to bool, returns value
                 \fI(public member function)\fP
   operator()    returns value
   \fI(C++14)\fP       \fI(public member function)\fP

.SH Member types

   Type       Definition
   value_type bool
   type       std::integral_constant<bool, value>

.SH Notes

   Each individual memory location in the C++ memory model, including the hidden memory
   locations used by language features (e.g. virtual table pointer), has scalar type
   (or is a sequence of adjacent bit-fields of non-zero length). Sequencing of
   side-effects in expression evaluation, inter-thread synchronization, and dependency
   ordering are all defined in terms of individual scalar objects.

.SH Possible implementation

   template<class T>
   struct is_scalar : std::integral_constant<bool, std::is_arithmetic<T>::value
                                                || std::is_enum<T>::value
                                                || std::is_pointer<T>::value
                                                || std::is_member_pointer<T>::value
                                                || std::is_null_pointer<T>::value>
   {};

.SH Example


// Run this code

 #include <iostream>
 #include <type_traits>
 #include <typeinfo>
 #include <utility>

 template<typename Head, typename... Tail>
 void are_scalars(Head&& head, Tail&&... tail)
 {
     using T = std::decay_t<decltype(head)>;

     std::cout << typeid(T).name() << " is "
               << (std::is_scalar_v<T> ? "" : "not ")
               << "a scalar\\n";

     if constexpr (sizeof... (Tail))
     {
         are_scalars(std::forward<decltype(tail)>(tail)...);
     }
 }

 int main()
 {
     struct S { int m; } s;
     int S::* mp = &S::m;
     enum class E { e };

     are_scalars(42, 3.14, E::e, "str", mp, nullptr, s);
 }

.SH Possible output:

 int is a scalar
 double is a scalar
 main::E is a scalar
 char const* is a scalar
 int main::S::* is a scalar
 nullptr is a scalar
 main::S is not a scalar

.SH See also

   is_arithmetic     checks if a type is an arithmetic type
   \fI(C++11)\fP           \fI(class template)\fP
   is_enum           checks if a type is an enumeration type
   \fI(C++11)\fP           \fI(class template)\fP
   is_pointer        checks if a type is a pointer type
   \fI(C++11)\fP           \fI(class template)\fP
   is_member_pointer checks if a type is a pointer to a non-static member function or
   \fI(C++11)\fP           object
                     \fI(class template)\fP
